﻿// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");
double num1 = 5.10;
Console.WriteLine(num1);
//中常见的数据类型 及其常用的方法
//一.值类型 ：值类型直接存储实际的数据，而不是指向某个对象的引用。它们通常用于表示简单的量化的数据。
Console.WriteLine($"一.值类型 ：值类型直接存储实际的数据，而不是指向某个对象的引用。它们通常用于表示简单的量化的数据。");

//1.整数类型sbyte, byte, short, ushort, int, uint, long 和 ulong 是常用的整数类型
Console.WriteLine($"1.整数类型sbyte, byte, short, ushort, int, uint, long 和 ulong 是常用的整数类型");
//换行
Console.WriteLine("\n");
int num2 = 510;
Console.WriteLine($"表示带符号的32为整数{num2}");
// SByte 类型
sbyte minValueSByte = sbyte.MinValue;
sbyte maxValueSByte = sbyte.MaxValue;
Console.WriteLine($" SByte 类型：SByte 最小范围/最大范围 : {minValueSByte} / {maxValueSByte}");
// Byte 类型
byte minByte = byte.MinValue;
byte maxByte = byte.MaxValue;
Console.WriteLine($"Byte 类型：Byte 最小范围/最大范围 Values: {minByte} / {maxByte}");
// Short 类型
short minShort = short.MinValue;
short maxShort = short.MaxValue;
Console.WriteLine($"Short 类型：Short 最小范围/最大范围 Values: {minShort} / {maxShort}");
// UShort 类型
ushort minUShort = ushort.MinValue;
ushort maxUShort = ushort.MaxValue;
Console.WriteLine($"UShort 类型：UShort 最小范围/最大范围 Values: {minUShort} / {maxUShort}");
// Int 类型
int minInt = int.MinValue;
int maxInt = int.MaxValue;
Console.WriteLine($"Int 类型：Int 最小范围/最大范围 Values: {minInt} / {maxInt}");
// UInt 类型
uint minUInt = uint.MinValue;
uint maxUInt = uint.MaxValue;
Console.WriteLine($"UInt 类型：UInt 最小范围/最大范围 Values: {minUInt} / {maxUInt}");
// Long 类型
long minLong = long.MinValue;
long maxLong = long.MaxValue;
Console.WriteLine($"Long 类型：Long 最小范围/最大范围 Values: {minLong} / {maxLong}");
// ULong 类型
ulong minULong = ulong.MinValue;
ulong maxULong = ulong.MaxValue;
Console.WriteLine($"ULong 类型：ULong 最小范围/最大范围 Values: {minULong} / {maxULong}");


//换行
Console.WriteLine("\n");

// 声明并初始化各类型变量
sbyte sb = -128;
    byte b = 255;
    short sh = -32768;
    ushort ush = 65535;
    int i = -2_147_483_648; // 数字分隔符 _ 提高可读性
    uint ui = 4_294_967_295u; // u 表示无符号整数
    long l = -9_223_372_036_854_775_808L; // L 表示长整型
    ulong ul = 18_446_744_073_709_551_615UL; // UL 表示无符号长整型

    // 打印各类型变量值及范围
    Console.WriteLine($"sbyte ({sb}): {sbyte.MinValue} to {sbyte.MaxValue}");
    Console.WriteLine($"byte ({b}): {byte.MinValue} to {byte.MaxValue}");
    Console.WriteLine($"short ({sh}): {short.MinValue} to {short.MaxValue}");
    Console.WriteLine($"ushort ({ush}): {ushort.MinValue} to {ushort.MaxValue}");
    Console.WriteLine($"int ({i}): {int.MinValue} to {int.MaxValue}");
    Console.WriteLine($"uint ({ui}): {uint.MinValue} to {uint.MaxValue}");
    Console.WriteLine($"long ({l}): {long.MinValue} to {long.MaxValue}");
    Console.WriteLine($"ulong ({ul}): {ulong.MinValue} to {ulong.MaxValue}");

    // 用户交互：输入一个整数并判断其类型
    Console.Write("\n请输入一个整数:");
    string input = Console.ReadLine();

    try
    {
        if (sbyte.TryParse(input, out sbyte resultSB))
            Console.WriteLine($"{input} 是有效的 sbyte.");
        else if (byte.TryParse(input, out byte resultB))
            Console.WriteLine($"{input} 是有效的 byte.");
        else if (short.TryParse(input, out short resultSH))
            Console.WriteLine($"{input} 是有效的 short.");
        else if (ushort.TryParse(input, out ushort resultUSH))
            Console.WriteLine($"{input} 是有效的 ushort.");
        else if (int.TryParse(input, out int resultI))
            Console.WriteLine($"{input} 是有效的 int.");
        else if (uint.TryParse(input, out uint resultUI))
            Console.WriteLine($"{input} 是有效的 uint.");
        else if (long.TryParse(input, out long resultL))
            Console.WriteLine($"{input} 是有效的 long.");
        else if (ulong.TryParse(input, out ulong resultUL))
            Console.WriteLine($"{input} 是有效的 ulong.");
        else
            Console.WriteLine("输入超出所有整数类型的范围!");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"发生错误: {ex.Message}");
    }

// 等待用户输入以便查看输出
Console.ReadLine();

//2.浮点类型float 和 double 用来表示带有小数部分的数值。
Console.WriteLine($"2.浮点类型float 和 double 用来表示带有小数部分的数值。");
    
// 定义并初始化 float 型变量
float floatValue = 3.0f;

// 定义并初始化 double 型变量
double doubleValue = 3.0;

// 执行除法运算
float resultFloat = (float)(1.0 / floatValue);
Console.WriteLine($"float单精度浮点数，占用 4 字节内存空间，具有大约 7 位十进制数字的有效精度");
double resultDouble = 100000000000000.0 / doubleValue;
Console.WriteLine($"double双精度浮点数，占用 8 字节内存空间，具有大约 15 到 16 位十进制数字的有效精度2");

// 输出结果到控制台
Console.WriteLine($"Using float: Result of division is {resultFloat:F7}");


Console.WriteLine($"Using double: Result of division is {resultDouble:F15}");



// 等待用户输入以便查看输出
Console.ReadLine();

//3.十进制类型 (decimal): 高精度的小数运算适合金融计算场景。
Console.WriteLine($"3.十进制类型 (decimal): 高精度的小数运算适合金融计算场景。");
// 初始化 decimal 类型变量
//换行
Console.WriteLine("\n");
decimal pricePerUnit = 49.99m; // 商品单价
Console.WriteLine($"decimal 是 C# 提供的一种高精度十进制数类型，适用于需要精确计算的场景，尤其是金融和货币计算。相比于 float 和 double，decimal 类型提供了更大的有效数字范围（高达 28-29 位），从而减少了浮点运算带来的舍入误差1。特性和适用场景高精度：decimal 支持最多 28-29 位有效数字，非常适合需要高度准确性的情境。低性能需求：尽管 decimal 的精度很高，但在计算速度方面较慢，因此不适用于高性能要求的场景5。默认值：decimal 的默认值为 0.0m，其中后缀 m 表明该数值属于 decimal 类型2。  并演示了其在金融计算中的实际应用场景：");
//换行
Console.WriteLine("\n");


int quantity = 10;             // 购买数量
// 计算总价
decimal totalPrice = pricePerUnit * quantity;
// 应用折扣
decimal discountRate = 0.15m; // 折扣率 15%
decimal discountedPrice = totalPrice * (1 - discountRate);

// 显示结果
Console.WriteLine($"商品单价: {pricePerUnit:C}");
Console.WriteLine($"购买数量: {quantity}件");
Console.WriteLine($"原价总计: {totalPrice:C}");
Console.WriteLine($"折扣比率: {discountRate:P}");
Console.WriteLine($"折后价格: {discountedPrice:C}");

// 等待用户输入以便查看输出
Console.ReadLine();
//4.布尔类型 (bool): 存储逻辑值 true 或 false。
Console.WriteLine($"4.布尔类型 (bool): 存储逻辑值 true 或 false。");
// 定义并初始化 bool 变量
bool isRaining = true;
bool hasUmbrella = false;

// 条件判断
if (isRaining && !hasUmbrella)
{
    Console.WriteLine("正在下雨并且你没有雨伞！请待在室内。");
}
else
{
    Console.WriteLine("你可以安全地外出！");
}

// 用户交互示例
Console.Write("你准备好了吗？(yes/no): ");
string input2 = Console.ReadLine().ToLower();

// 将字符串转换为布尔值
bool userReady = input2 == "yes";

if (userReady)
{
    Console.WriteLine("太好了！我们开始吧。");
}
else
{
    Console.WriteLine("好吧，慢慢来。");
}
// 等待用户输入以便查看输出
Console.ReadLine();
//5.字符类型 (char): 存储单个 Unicode 字符
Console.WriteLine($"5.字符类型 (char): 存储单个 Unicode 字符");
Console.WriteLine($"在 C# 中，char 是一种基本的数据类型，用来表示单个的 Unicode 字符。每一个 char 类型的变量实际上是一个 16 位无符号整数（UTF-16 编码），范围是从 \u0000 到 \uffff1");
//换行
Console.WriteLine("\n");
Console.WriteLine($"可以直接通过赋值一个字符字面量来创建并初始化一个 char 变量：");
char myChar = 'A';
Console.WriteLine(myChar); // 输出 A

Console.WriteLine($"也可以利用 Unicode 转义序列来定义特殊字符或不可见字符：");
char unicodeChar = '\u0041'; // 对应的是大写字母 A
Console.WriteLine(unicodeChar); // 输出 A

Console.WriteLine($"尽管 char 属于数值类别的一部分，但它与其他数值类型之间并没有提供默认的隐式转换机制。如果需要进行这样的操作，则必须采用显式的强制类型转换方式实现2:");
int numericValue = (int)'Z'; // 将字符 Z 映射为其对应的 ASCII 数值 90
Console.WriteLine(numericValue);

char convertedBack = (char)90; // 把整数重新映射回相应的字符形式
Console.WriteLine(convertedBack);


Console.WriteLine($"C# 的 char 数据类型提供了丰富的静态方法集合，允许开发者执行各种各样的验证、比较以及其他实用功能。下面列举了一些常用的函数及其用途3:");
//换行
Console.WriteLine("\n");
Console.WriteLine($"判断字母大小写");
char lowerCaseLetter = 'a';
Console.WriteLine(char.IsLower(lowerCaseLetter)); // True

char upperCaseLetter = 'B';
Console.WriteLine(char.IsUpper(upperCaseLetter)); // True

Console.WriteLine($"检测空白字符");
char spaceCharacter = ' ';
Console.WriteLine(char.IsWhiteSpace(spaceCharacter)); // True

Console.WriteLine($"数字判定");
char digitSymbol = '7';
Console.WriteLine(char.IsDigit(digitSymbol)); // True

Console.WriteLine($"拼接字符串中的转义字符");
char tabulation = '\t';
Console.WriteLine($"今天也{tabulation}努力学习！");
// 输出：今天也要	努力学习！
// 等待用户输入以便查看输出
Console.ReadLine();

//二.引用类型 ：引用类型并不直接保存数据本身，而是通过引用访问堆上的对象实例
Console.WriteLine($"二.引用类型 ：引用类型并不直接保存数据本身，而是通过引用访问堆上的对象实例");
//换行
Console.WriteLine("\n");
//1.字符串类型 (string): 特殊的引用类型，在许多情况下表现得像值类型。
//常用方法包括但不限于：.Length: 获取字符串长度。.Substring(int startIndex, int length ?):.ToLower() / .ToUpper(): 将字符串转换为大写或小写形式。截取子串。
Console.WriteLine($"1.字符串类型 (string): 特殊的引用类型，在许多情况下表现得像值类型。//常用方法包括但不限于：.Length: 获取字符串长度。.Substring(int startIndex, int length ?):.ToLower() / .ToUpper(): 将字符串转换为大写或小写形式。截取子串。");
//换行
Console.WriteLine("\n");
Console.WriteLine($" Length 方法该属性用于获取字符串中字符的数量。它返回一个整数值，表示字符串的长度。");
string exampleString = "Hello, World!";
Console.WriteLine(exampleString.Length); // 输出 13 [^1]


//换行
Console.WriteLine("\n");
Console.WriteLine($"Substring 方法此方法用于从指定索引处提取子字符串。可以通过传递起始索引以及可选的长度参数来定义要提取的部分.");
string sentence = "C# programming is fun.";
// 提取从第3个字符开始到结束的子字符串
string subStr1 = sentence.Substring(3);
Console.WriteLine(subStr1); // 输出 "programming is fun."

// 提取从第3个字符开始，长度为11的子字符串
string subStr2 = sentence.Substring(3, 11);
Console.WriteLine(subStr2); // 输出 "programming" [^4]



//换行
Console.WriteLine("\n");
Console.WriteLine($"ToLower 和 ToUpper 方法这两个方法分别用于将整个字符串转换为小写或大写形式。");
string mixedCase = "MiXeD cAsE";
string lowerCase = mixedCase.ToLower();
Console.WriteLine(lowerCase); // 输出 "mixed case"

string upperCase = mixedCase.ToUpper();
Console.WriteLine(upperCase); // 输出 "MIXED CASE" [^3]

//换行
Console.WriteLine("\n");
Console.WriteLine($"综合示例：在控制台程序中演示这些方法以下是一个完整的控制台应用程序，综合展示了上述几种常见字符串处理方法的应用场景：");
string input3 = "The Quick Brown Fox Jumps Over The Lazy Dog";

// 使用 Length 获取输入字符串的总长度
Console.WriteLine($"Original String: {input3}");
Console.WriteLine($"Total Characters: {input3.Length}");

// 使用 Substring 截取部分字符串
string substringExample = input3.Substring(4, 10);
Console.WriteLine($"Substring Example (from index 4 to 14): {substringExample}");

// 转换为全小写
string lowercaseVersion = input3.ToLower();
Console.WriteLine($"Lowercase Version: {lowercaseVersion}");

// 转换为全大写
string uppercaseVersion = input3.ToUpper();
Console.WriteLine($"Uppercase Version: {uppercaseVersion}");

Console.ReadKey(); // 等待用户按键退出


//2.数组类型 (Array): 定义一组相同类型的变量集合。使用索引来访问元素。
//换行

Console.WriteLine($"2.数组类型 (Array): 定义一组相同类型的变量集合。使用索引来访问元素。");
Console.WriteLine("\n");
Console.WriteLine($"数组的定义数组是一种固定大小的数据结构，能够存储相同类型的多个元素。在 C# 中，可以通过指定数组的元素类型来声明数组。如果需要存储任意类型的元素，则可以将数组的类型设置为 object，因为所有类型都直接或间接从 System.Object 类派生而来1。");
Console.WriteLine("\n");
Console.WriteLine($"数组的声明与初始化以下是几种常见的数组声明和初始化方式：");
// 方式一：使用关键字 new 初始化数组并赋值
int[] numbers = new int[] { 1, 2, 3, 4 };

// 方式二：省略 new 关键字进行隐式初始化
double[] decimals = { 1.1, 2.2, 3.3 };

// 方式三：创建未初始化的数组
char[] characters = new char[5]; // 创建一个长度为 5 的字符数组，默认值为 '\0'

Console.WriteLine("\n");
Console.WriteLine($" 访问数组元素\r\n通过索引来访问数组中的单个元素。注意，C# 数组的索引是从零开始的。");
int[] data = { 10, 20, 30 };
Console.WriteLine(data[0]); // 输出第一个元素 10 [^2]

Console.WriteLine("\n");
Console.WriteLine($"遍历数组遍历数组有多种方法，包括传统的 for 循环、反向循环以及增强型 foreach 循环。");
Console.WriteLine("\n");
Console.WriteLine($"正向循环");
int[] array = { 1, 2, 3, 4, 5 };
for (int i2 = 0; i2 < array.Length; i2++)
{
    Console.WriteLine(array[i2]);
}

Console.WriteLine("\n");
Console.WriteLine($"反向循环");
for (int i2 = array.Length - 1; i2 >= 0; i2--)
{
    Console.WriteLine(array[i2]);
}

Console.WriteLine("\n");
Console.WriteLine($"使用 foreach 遍历");
foreach (int item in array)
{
    Console.WriteLine(item);
}

Console.WriteLine("\n");
Console.WriteLine($"数组的常用方法及属性以下是一些常用的数组操作方法及其功能：");
Console.WriteLine($"Length: 返回数组中元素的数量。");
int size = array.Length;
Console.WriteLine(size); // 输出数组长度 

Console.WriteLine("\n");
Console.WriteLine($"Sort: 对数组中的元素按升序排列。");
int[] unsortedArray = { 5, 3, 8, 1 };
Array.Sort(unsortedArray);
Console.WriteLine(string.Join(", ", unsortedArray)); // 输出 "1, 3, 5, 8" 

Console.WriteLine("\n");
Console.WriteLine($"Reverse: 将数组中的元素顺序反转。");
Array.Reverse(unsortedArray);
Console.WriteLine(string.Join(", ", unsortedArray)); // 输出 "8, 5, 3, 1" [^2]

Console.WriteLine("\n");
Console.WriteLine($"Clear: 清除数组的一部分或全部内容，将其置为默认值（对于整数数组来说是 0）。");
Array.Reverse(unsortedArray);
Console.WriteLine(string.Join(", ", unsortedArray)); // 输出 "8, 5, 3, 1" [^2]

Console.WriteLine("\n");
Console.WriteLine($"CopyTo: 将当前数组的内容复制到另一个数组中。");
int[] sourceArray = { 1, 2, 3 };
int[] destinationArray = new int[sourceArray.Length];
sourceArray.CopyTo(destinationArray, 0);
Console.WriteLine(string.Join(", ", destinationArray)); // 输出 "1, 2, 3" [^2]

Console.WriteLine("\n");
Console.WriteLine($"控制台应用示例下面是一个完整的控制台应用程序，展示了如何定义、初始化、访问和操作数组：");
// 定义并初始化数组
int[] numbers2 = { 7, 3, 9, 1, 5 };

// 打印原始数组
Console.WriteLine("Original Array:");
foreach (var num in numbers2)
    Console.Write(num + " ");
Console.WriteLine();

// 排序数组
Array.Sort(numbers2);
Console.WriteLine("Sorted Array:");
foreach (var num in numbers2)
    Console.Write(num + " ");
Console.WriteLine();

// 反转数组
Array.Reverse(numbers2);
Console.WriteLine("Reversed Array:");
foreach (var num in numbers2)
    Console.Write(num + " ");

Console.ReadKey();

//3.可空类型 (Nullable<T>): 允许值类型具有 null 值的能力。这对于处理数据库字段非常有用，因为某些列可能为空。
Console.WriteLine($"3.可空类型 (Nullable<T>): 允许值类型具有 null 值的能力。这对于处理数据库字段非常有用，因为某些列可能为空。");
Console.WriteLine("\n");
Console.WriteLine($"可空类型的定义\r\n在 C# 中，Nullable<T> 是一种特殊的泛型结构体，允许值类型具有 null 值。这使得原本不允许为 null 的值类型（如 int, bool, 或者自定义的结构体）也可以表示不存在的状态2。");

Console.WriteLine("\n");
Console.WriteLine($"可空类型的声明与初始化\r\n以下是几种常见的可空类型声明和初始化方式：");
// 声明一个可空整数并赋初值
int? nullableInt = null;

// 赋予实际值
nullableInt = 42;

// 使用简化语法声明其他可空类型
bool? nullableBool = true;
double? nullableDouble = 3.14;

Console.WriteLine("\n");
Console.WriteLine($"访问可空类型的值\r\n通过 .HasValue 和 .Value 属性来判断是否存在有效值以及获取该值。");
if (nullableInt.HasValue)
{
    Console.WriteLine($"The value is: {nullableInt.Value}");
}
else
{
    Console.WriteLine("No value assigned.");
}


Console.WriteLine("\n");
Console.WriteLine($"默认值处理当可空类型未被赋值时，默认状态是 .HasValue 返回 false 并且无法访问 .Value 属性。为了避免运行时异常，通常会结合使用 ?? 运算符提供默认值。");
int defaultValue = nullableInt ?? 0; // 如果 nullableInt 为 null，则返回 0
Console.WriteLine(defaultValue);


Console.WriteLine("\n");
Console.WriteLine($"常见方法的应用以下是一些关于可空类型的常见操作及其用途：判断是否为空.HasValue 属性用于检测对象是否包含有效的值。");
bool? flag = null;
if (!flag.HasValue)
{
    Console.WriteLine("Flag has no value."); 
}

Console.WriteLine("\n");
Console.WriteLine($"获取值或抛出异常.GetValueOrDefault() 方法会在没有值的情况下返回指定的默认值；而直接访问 .Value 会引起异常。");
try
{
    Console.WriteLine(nullableInt.Value); // 抛出 InvalidOperationException 若为 null
}
catch (InvalidOperationException ex)
{
    Console.WriteLine(ex.Message);
}

// 更安全的方式
Console.WriteLine(nullableInt.GetValueOrDefault(-1)); // 输出 -1 当为 null 时

Console.WriteLine("\n");
Console.WriteLine($"结合逻辑运算由于布尔值可以是可空的，因此需要特别注意条件语句中的行为。");
bool? result = null;
if (result == true) // 明确检查是否为真
{
    Console.WriteLine("Result is True");
}
else if (result == false) // 明确检查是否为假
{
    Console.WriteLine("Result is False");
}
else
{
    Console.WriteLine("Result is Null"); 
}





//三.指针类型：指针类型主要用于低级编程或者与非托管资源交互的情况。创建指针时需显式声明并分配内存空间。
Console.WriteLine("\n");
Console.WriteLine($" 三.指针类型：指针类型主要用于低级编程或者与非托管资源交互的情况。创建指针时需显式声明并分配内存空间。");

Console.WriteLine("\n");
Console.WriteLine($"  指针类型的基础概念在 C# 中，指针是一种特殊的数据类型，它存储的是内存地址而非具体值。使用指针时需要注意安全性问题，因此默认情况下，C# 不支持不安全代码的编译。如果需要使用指针，则需启用 unsafe 上下文1。");


Console.WriteLine("\n");
Console.WriteLine($"启用 unsafe 上下文要在 C# 程序中使用指针，必须显式标记代码块为 unsafe 并在项目设置中允许不安全代码。");






       
    









